import { ref } from 'vue'

export interface Notification {
  id: string
  type: 'success' | 'error' | 'warning' | 'info'
  title: string
  message?: string
  duration?: number // 毫秒，默认3000
}

const notifications = ref<Notification[]>([])
const notificationTimers = ref<Map<string, number>>(new Map())
const autoCloseCallbacks = ref<Map<string, () => void>>(new Map())
const pausedTimers = ref<Map<string, { remainingTime: number; startTime: number }>>(new Map())

export function useNotification() {
  // 添加通知
  function addNotification(notification: Omit<Notification, 'id'>) {
    const id = generateId()
    const newNotification: Notification = {
      id,
      duration: 3000,
      ...notification,
    }

    notifications.value.push(newNotification)

    // 自动移除通知
    if (newNotification.duration && newNotification.duration > 0) {
      const timerId = setTimeout(() => {
        // 检查通知是否仍然存在
        const notificationExists = notifications.value.some((n) => n.id === id)
        if (!notificationExists) {
          return // 通知已被手动移除，无需处理
        }

        // 检查是否有自定义的自动关闭回调
        const callback = autoCloseCallbacks.value.get(id)
        if (callback) {
          callback()
          // 不在这里移除通知，让回调函数处理移除逻辑
        } else {
          // 默认行为：直接移除通知
          removeNotification(id)
        }
      }, newNotification.duration)

      // 保存定时器ID，以便在手动关闭时取消
      notificationTimers.value.set(id, timerId)
    }

    return id
  }

  // 移除通知
  function removeNotification(id: string) {
    const index = notifications.value.findIndex((n) => n.id === id)
    if (index > -1) {
      notifications.value.splice(index, 1)
    }

    // 清除自动移除的定时器
    const timerId = notificationTimers.value.get(id)
    if (timerId) {
      clearTimeout(timerId)
      notificationTimers.value.delete(id)
    }

    // 清除自动关闭回调
    autoCloseCallbacks.value.delete(id)

    // 清除暂停的计时器信息
    pausedTimers.value.delete(id)
  }

  // 清除所有通知
  function clearNotifications() {
    // 清除所有定时器
    notificationTimers.value.forEach((timerId) => clearTimeout(timerId))
    notificationTimers.value.clear()

    // 清除所有自动关闭回调
    autoCloseCallbacks.value.clear()

    // 清除所有暂停的计时器信息
    pausedTimers.value.clear()

    // 清除所有通知
    notifications.value = []
  }

  // 设置自动关闭回调
  function setAutoCloseCallback(id: string, callback: () => void) {
    autoCloseCallbacks.value.set(id, callback)
  }

  // 暂停通知的自动关闭计时器
  function pauseTimer(id: string) {
    const timerId = notificationTimers.value.get(id)
    if (!timerId) return

    // 清除当前定时器
    clearTimeout(timerId)
    notificationTimers.value.delete(id)

    // 获取通知的原始持续时间
    const notification = notifications.value.find((n) => n.id === id)
    if (!notification || !notification.duration) return

    // 计算剩余时间
    const pausedInfo = pausedTimers.value.get(id)
    let remainingTime: number

    if (pausedInfo) {
      // 如果已经暂停过，计算新的剩余时间
      const elapsed = Date.now() - pausedInfo.startTime
      remainingTime = Math.max(0, pausedInfo.remainingTime - elapsed)
    } else {
      // 首次暂停，假设已经过了一半时间（简化处理）
      remainingTime = notification.duration / 2
    }

    // 保存暂停信息
    pausedTimers.value.set(id, {
      remainingTime,
      startTime: Date.now(),
    })
  }

  // 恢复通知的自动关闭计时器
  function resumeTimer(id: string) {
    const pausedInfo = pausedTimers.value.get(id)
    if (!pausedInfo) return

    // 创建新的定时器
    const timerId = setTimeout(() => {
      // 检查是否有自定义的自动关闭回调
      const callback = autoCloseCallbacks.value.get(id)
      if (callback) {
        callback()
        // 不在这里移除通知，让回调函数处理移除逻辑
      } else {
        // 默认行为：直接移除通知
        removeNotification(id)
      }
    }, pausedInfo.remainingTime)

    // 保存新的定时器ID
    notificationTimers.value.set(id, timerId)

    // 清除暂停信息
    pausedTimers.value.delete(id)
  }

  // 成功通知
  function showSuccess(title: string, message?: string, duration?: number) {
    return addNotification({
      type: 'success',
      title,
      message,
      duration,
    })
  }

  // 错误通知
  function showError(title: string, message?: string, duration?: number) {
    return addNotification({
      type: 'error',
      title,
      message,
      duration,
    })
  }

  // 警告通知
  function showWarning(title: string, message?: string, duration?: number) {
    return addNotification({
      type: 'warning',
      title,
      message,
      duration,
    })
  }

  // 信息通知
  function showInfo(title: string, message?: string, duration?: number) {
    return addNotification({
      type: 'info',
      title,
      message,
      duration,
    })
  }

  // 清理所有资源的函数
  function cleanup() {
    // 清除所有定时器
    notificationTimers.value.forEach((timerId) => clearTimeout(timerId))
    notificationTimers.value.clear()

    // 清除所有自动关闭回调
    autoCloseCallbacks.value.clear()

    // 清除所有暂停的计时器信息
    pausedTimers.value.clear()

    // 清除所有通知
    notifications.value = []
  }

  // 移除组件卸载时的清理，让使用方决定何时清理
  // 这样可以避免在多个组件中使用同一个 composable 时过早清理资源

  return {
    notifications,
    addNotification,
    removeNotification,
    clearNotifications,
    setAutoCloseCallback,
    pauseTimer,
    resumeTimer,
    showSuccess,
    showError,
    showWarning,
    showInfo,
    cleanup, // 导出清理函数，供需要时手动调用
  }
}

// 生成唯一ID
function generateId(): string {
  return `notification-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
}
